#include <iostream>
using namespace std;

class A
{
public:
	A() { ++_scount; }
	A(const A& t) 
	{
		GetACount(); //非静态的可以访问静态的

		++_scount; 
	}
	~A() 
	{ 
		//--_scount;  //减去创建的临时变量
	}
	// 没有this指针，只能访问静态成员
	static int GetACount() //静态成员函数
	{
		return _scount; 
	}

private:
	//声明
	int _a1;
	int _a2;

public:
	// 静态区，不存在对象中
	// 不能给缺省值，因为缺省值是给初始化列表
	// 他在静态区，不在对象中，不走初始化列表
	// 属于所有整个类，属于所有对象
	static int _scount;
};

int A::_scount = 0; //静态成员变量的定义，需要定义在全局中

A func()
{
	A aa4;
	return aa4;
}

int main()
{
	A aa1;
	cout << sizeof(aa1) << endl;

	/*aa1._scount++;
	cout << A::_scount << endl;*/

	//  统计A 类型的对象创建多少个
	A aa2;
	A aa3(aa1); // 3

	func();  // 4
	cout << A::_scount << endl;

	cout << A::GetACount() << endl;

	return 0;
}


// ———————————————— 从1加到n
//用静态成员变量来做
//调用n次构造函数
class Sum {
public:
	Sum()//每构造一次就调用一次
	{
		_ret += _i;
		_i++;
	}
	static int Getret()
	{
		return _ret;
	}

private:
	static int _i;
	static int _ret;
};

int Sum::_i = 1;
int Sum::_ret = 0;

class Solution {
public:
	
	int Sum_Solution(int n) {
		Sum arr[n];// //定义n个sum对象 n次构造

		return Sum::Getret();
	}
};



// ———————————— 内部类改造


class Solution {
public:
	class Sum { //此时Sum变成Solution的专属类，封装起来
	public:
		Sum()//每构造一次就调用一次
		{
			_ret += _i;
			_i++;
		}
	};
		static int _i;
		static int _ret;

	int Sum_Solution(int n) {
		Sum arr[n];// //定义n个sum对象 n次构造

		return _ret;
	}
};

int Solution::_i = 1;
int Solution::_ret = 0;